{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2、深层神经网络（DNN）分类模型",
   "id": "1a6c85778bf61dd1"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:35.927587Z",
     "start_time": "2025-03-07T12:57:32.905113Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import os\n",
    "import sys\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms  # 将图片转换为tensor"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 打印系统信息",
   "id": "1f9d7f5ef9f5b40e"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:35.942595Z",
     "start_time": "2025-03-07T12:57:35.927587Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "id": "cb10e18f5766dc8d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.9.1\n",
      "numpy 2.0.0\n",
      "pandas 2.2.2\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据集以及数据预处理",
   "id": "c668a4ef75f01060"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:35.973630Z",
     "start_time": "2025-03-07T12:57:35.942595Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将图片转换为tensor\n",
    "    transforms.Normalize((0.2860,), (0.3205,))  # 归一化\n",
    "])\n",
    "\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "batch_size = 32\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size, shuffle=False)"
   ],
   "id": "cdf81ebed569ebf4",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义模型",
   "id": "ac6d8c94ed111ca8"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:35.983875Z",
     "start_time": "2025-03-07T12:57:35.973630Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms  # 预处理层，标准化\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            nn.SELU(),\n",
    "            nn.AlphaDropout(p=0.2)  # 增加dropout，p=0.2表示以0.2的概率将某些神经元置0，防止过拟合\n",
    "\n",
    "        )\n",
    "        # 加19层:所谓的DNN就是多个全连接层堆叠而成add_module()方法可以添加多个模块\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        # print('''初始化权重''')\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):  #判断m是否为全连接层\n",
    "                nn.init.xavier_uniform_(m.weight)  # xavier 均匀分布初始化权重\n",
    "                nn.init.zeros_(m.bias)  # 全零初始化偏置项\n",
    "        # print('''初始化权重完成''')\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        # x = self.transforms(x)  #标准化\n",
    "        x = self.flatten(x)\n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "total = 0\n",
    "# 计算模型参数数量\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\") #np.prod是计算张量的元素个数\n",
    "    # print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total  #模型参数数量\n"
   ],
   "id": "dd323365c40aa6a6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.int64(271410)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义损失函数和优化器",
   "id": "20e3452a91e25d4a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:35.986751Z",
     "start_time": "2025-03-07T12:57:35.983875Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)"
   ],
   "id": "22f030d2dbb1c736",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 定义评估函数",
   "id": "934c2422f99f4639"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:36.019340Z",
     "start_time": "2025-03-07T12:57:35.986751Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_func):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_func(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)  # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "2c91772c89ffe099",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练函数",
   "id": "f4a4d0957eadc3e1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:57:36.024099Z",
     "start_time": "2025-03-07T12:57:36.019340Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_func,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_func(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_func)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "e1a5883fb896c195",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:59:43.777089Z",
     "start_time": "2025-03-07T12:57:36.024099Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_func,\n",
    "    optimizer,\n",
    "    eval_step=len(train_loader)\n",
    ")"
   ],
   "id": "2ef7b075af3b4fe2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/18750 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "20021c604e8f4386bd0db7a120897be5"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:59:43.870855Z",
     "start_time": "2025-03-07T12:59:43.777089Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "    # print(train_df.head())\n",
    "    # print(val_df.head())\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)  #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))  #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        #index是步数，item是指标名字\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data = range(0, train_df.index[-1], 5000)  #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))  #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ],
   "id": "609d7d8c6d1471a6",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-07T12:59:45.076384Z",
     "start_time": "2025-03-07T12:59:43.870855Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_func)\n",
    "print(f\"loss:{loss:.4f}\\naccuracy:{acc:.4f}\")"
   ],
   "id": "a132c5e875313c06",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:0.4028\n",
      "accuracy:0.8729\n"
     ]
    }
   ],
   "execution_count": 10
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
